🐍 Programmazione Orientata agli Oggetti in Python

class SistemaComplesso:
    pass  # pass significa "non fare niente", è come un segnaposto

# Creiamo un'istanza (un oggetto) di questa classe
oggetto = SistemaComplesso()
print(type(oggetto))  # Output: <class '__main__.SistemaComplesso'>

class SistemaComplesso:
    """
    Questa classe rappresenta un sistema complesso per la gestione
    di operazioni matematiche avanzate.
    
    La classe fornisce metodi per calcoli matriciali, trasformate
    di Fourier e altre operazioni di algebra lineare.
    
    Attributi:
        dimensione (int): La dimensione del sistema
        matrice (list): La matrice principale del sistema
    """
    pass

# Possiamo visualizzare la documentazione usando help()
help(SistemaComplesso)

class Persona:
    """
    Rappresenta una persona con nome, età e città di residenza.
    """
    
    def __init__(self, nome, eta, citta="Non specificata"):
        """
        Inizializza una nuova persona.
        
        Args:
            nome (str): Il nome della persona
            eta (int): L'età della persona
            citta (str, opzionale): La città di residenza. Default: "Non specificata"
        """
        self.nome = nome        # Attributo pubblico
        self.eta = eta          # Attributo pubblico
        self.citta = citta      # Attributo pubblico con default
        self.hobbies = []       # Lista vuota di hobbies
    
    def presentati(self):
        """Stampa una presentazione della persona."""
        return f"Ciao, sono {self.nome}, ho {self.eta} anni e vivo a {self.citta}."

# Creiamo alcune persone
persona1 = Persona("Mario", 30, "Roma")
persona2 = Persona("Laura", 25, "Milano")
persona3 = Persona("Giovanni", 35)  # città usa il default

print(persona1.presentati())
print(persona2.presentati())
print(persona3.presentati())

class FileManager:
    """Gestisce l'apertura e chiusura di un file."""
    
    def __init__(self, nome_file):
        self.nome_file = nome_file
        print(f"📂 FileManager creato per '{nome_file}'")
    
    def __del__(self):
        print(f"🗑️  FileManager per '{self.nome_file}' è stato distrutto")

# Creiamo e distruggiamo oggetti
fm1 = FileManager("dati.txt")
fm2 = FileManager("config.ini")

del fm1  # Eliminiamo esplicitamente fm1

print("Fine del programma")
# fm2 viene distrutto automaticamente qui quando il programma termina

class Veicolo:
    """Classe base per tutti i veicoli."""
    
    def __init__(self, marca, modello, anno):
        self.marca = marca
        self.modello = modello
        self.anno = anno
        self.acceso = False
    
    def accendi(self):
        self.acceso = True
        print(f"🔑 {self.marca} {self.modello} è stato acceso")
    
    def spegni(self):
        self.acceso = False
        print(f"🔒 {self.marca} {self.modello} è stato spento")
    
    def info(self):
        return f"{self.marca} {self.modello} del {self.anno}"


class Automobile(Veicolo):  # Automobile eredita da Veicolo
    """Rappresenta un'automobile (veicolo a 4 ruote)."""
    
    def __init__(self, marca, modello, anno, num_porte):
        # Chiamiamo il costruttore della classe base
        super().__init__(marca, modello, anno)
        # Aggiungiamo un attributo specifico per le automobili
        self.num_porte = num_porte
    
    def clacson(self):
        print(f"🚗 BEEP BEEP! - {self.info()}")


class Motocicletta(Veicolo):  # Anche Motocicletta eredita da Veicolo
    """Rappresenta una motocicletta (veicolo a 2 ruote)."""
    
    def __init__(self, marca, modello, anno, cilindrata):
        super().__init__(marca, modello, anno)
        self.cilindrata = cilindrata
    
    def impennata(self):
        if self.acceso:
            print(f"🏍️  VROOOOM! Impennata con la {self.info()}!")
        else:
            print("⚠️  Prima devi accendere la moto!")


# Usiamo le classi
auto = Automobile("Fiat", "500", 2020, 3)
moto = Motocicletta("Ducati", "Monster", 2021, 821)

# Entrambi hanno i metodi di Veicolo
auto.accendi()
moto.accendi()

# Ma hanno anche i loro metodi specifici
auto.clacson()
moto.impennata()

class Volante:
    """Mixin per oggetti che possono volare."""
    
    def vola(self):
        print(f"✈️  {self.__class__.__name__} sta volando!")


class Nuotante:
    """Mixin per oggetti che possono nuotare."""
    
    def nuota(self):
        print(f"🏊 {self.__class__.__name__} sta nuotando!")


class Anatra(Volante, Nuotante):
    """Un'anatra può sia volare che nuotare!"""
    
    def __init__(self, nome):
        self.nome = nome
    
    def verso(self):
        print(f"🦆 {self.nome} fa: Quack quack!")


# Creiamo un'anatra
paperina = Anatra("Paperina")
paperina.verso()
paperina.vola()    # Metodo ereditato da Volante
paperina.nuota()   # Metodo ereditato da Nuotante

class Animale:
    def __init__(self, nome, eta):
        self.nome = nome
        self.eta = eta
        print(f"🐾 Creato animale: {nome}")
    
    def saluta(self):
        print(f"👋 Ciao, sono {self.nome}")


class Cane(Animale):
    def __init__(self, nome, eta, razza):
        # Chiamiamo __init__ di Animale per inizializzare nome ed eta
        super().__init__(nome, eta)
        # Poi aggiungiamo il nostro attributo specifico
        self.razza = razza
        print(f"🐕 È un cane di razza {razza}")
    
    def saluta(self):
        # Chiamiamo prima il saluto di Animale
        super().saluta()
        # Poi aggiungiamo il nostro comportamento specifico
        print(f"🐕 Bau bau! Sono un {self.razza}!")


# Creiamo un cane
fido = Cane("Fido", 3, "Labrador")
fido.saluta()

from math import pi

class FiguraGeometrica:
    """
    Classe base astratta per tutte le figure geometriche.
    Definisce l'interfaccia che tutte le figure devono implementare.
    """
    
    def area(self):
        """Calcola l'area della figura. Deve essere implementato dalle sottoclassi."""
        raise NotImplementedError('Metodo area() non implementato')
    
    def perimetro(self):
        """Calcola il perimetro della figura. Deve essere implementato dalle sottoclassi."""
        raise NotImplementedError('Metodo perimetro() non implementato')
    
    def __str__(self):
        """Rappresentazione testuale della figura."""
        return "Figura geometrica generica"


class Cerchio(FiguraGeometrica):
    """Rappresenta un cerchio."""
    
    def __init__(self, raggio):
        if raggio <= 0:
            raise ValueError("Il raggio deve essere positivo!")
        self.raggio = raggio
    
    def area(self):
        """Calcola l'area del cerchio: π × r²"""
        return pi * self.raggio ** 2
    
    def perimetro(self):
        """Calcola la circonferenza: 2 × π × r"""
        return 2 * pi * self.raggio
    
    def __str__(self):
        return f"Cerchio con raggio {self.raggio:.2f}"


class Quadrato(FiguraGeometrica):
    """Rappresenta un quadrato."""
    
    def __init__(self, lato):
        if lato <= 0:
            raise ValueError("Il lato deve essere positivo!")
        self.lato = lato
    
    def area(self):
        """Calcola l'area del quadrato: l²"""
        return self.lato ** 2
    
    def perimetro(self):
        """Calcola il perimetro: 4 × l"""
        return 4 * self.lato
    
    def __str__(self):
        return f"Quadrato con lato {self.lato:.2f}"


class Rettangolo(FiguraGeometrica):
    """Rappresenta un rettangolo."""
    
    def __init__(self, base, altezza):
        if base <= 0 or altezza <= 0:
            raise ValueError("Base e altezza devono essere positive!")
        self.base = base
        self.altezza = altezza
    
    def area(self):
        """Calcola l'area del rettangolo: base × altezza"""
        return self.base * self.altezza
    
    def perimetro(self):
        """Calcola il perimetro: 2 × (base + altezza)"""
        return 2 * (self.base + self.altezza)
    
    def __str__(self):
        return f"Rettangolo con lati {self.base:.2f} e {self.altezza:.2f}"


class Triangolo(FiguraGeometrica):
    """Rappresenta un triangolo."""
    
    def __init__(self, base, altezza, lato1, lato2, lato3):
        if base <= 0 or altezza <= 0:
            raise ValueError("Base e altezza devono essere positive!")
        self.base = base
        self.altezza = altezza
        self.lato1 = lato1
        self.lato2 = lato2
        self.lato3 = lato3
    
    def area(self):
        """Calcola l'area del triangolo: (base × altezza) / 2"""
        return (self.base * self.altezza) / 2
    
    def perimetro(self):
        """Calcola il perimetro: somma dei tre lati"""
        return self.lato1 + self.lato2 + self.lato3
    
    def __str__(self):
        return f"Triangolo con base {self.base:.2f} e altezza {self.altezza:.2f}"


# ===============================
# POLIMORFISMO IN AZIONE!
# ===============================

def stampa_info_figura(figura):
    """
    Questa funzione può lavorare con QUALSIASI figura geometrica!
    Non le importa se è un cerchio, un quadrato, un triangolo, ecc.
    Questo è il POLIMORFISMO!
    """
    print("=" * 50)
    print(f"📐 {figura}")
    print(f"📏 Area: {figura.area():.2f}")
    print(f"📐 Perimetro: {figura.perimetro():.2f}")


# Creiamo una lista di figure diverse
figure = [
    Cerchio(5),
    Quadrato(4),
    Rettangolo(6, 3),
    Triangolo(4, 5, 3, 4, 5),
    Cerchio(2.5),
]

# Il bello del polimorfismo: usiamo lo stesso codice per tutte le figure!
print("🎨 CATALOGO FIGURE GEOMETRICHE
")
for figura in figure:
    stampa_info_figura(figura)

# Calcoliamo l'area totale di tutte le figure
area_totale = sum(figura.area() for figura in figure)
print("
" + "=" * 50)
print(f"📊 Area totale di tutte le figure: {area_totale:.2f}")

class ContoBancario:
    """
    Esempio di incapsulamento con diversi livelli di visibilità.
    """
    
    def __init__(self, titolare, saldo_iniziale):
        # Attributo pubblico - può essere acceduto liberamente
        self.titolare = titolare
        
        # Attributo "protetto" (convenzione: uso interno, ma accessibile)
        self._numero_conto = f"IT{id(self):015d}"
        
        # Attributo "privato" (name mangling per protezione)
        self.__saldo = saldo_iniziale
        
        # Contatore privato per le transazioni
        self.__num_transazioni = 0
    
    def deposita(self, importo):
        """Metodo pubblico per depositare denaro."""
        if importo > 0:
            self.__saldo += importo
            self.__num_transazioni += 1
            print(f"💰 Depositati €{importo:.2f}. Nuovo saldo: €{self.__saldo:.2f}")
        else:
            print("⚠️  L'importo deve essere positivo!")
    
    def preleva(self, importo):
        """Metodo pubblico per prelevare denaro."""
        if importo > 0:
            if self.__saldo >= importo:
                self.__saldo -= importo
                self.__num_transazioni += 1
                print(f"💸 Prelevati €{importo:.2f}. Nuovo saldo: €{self.__saldo:.2f}")
            else:
                print("❌ Fondi insufficienti!")
        else:
            print("⚠️  L'importo deve essere positivo!")
    
    def get_saldo(self):
        """Metodo pubblico per leggere il saldo (getter)."""
        return self.__saldo
    
    def get_stats(self):
        """Metodo pubblico per ottenere statistiche."""
        return {
            'titolare': self.titolare,
            'numero_conto': self._numero_conto,
            'saldo': self.__saldo,
            'transazioni': self.__num_transazioni
        }
    
    def _metodo_interno(self):
        """Metodo protetto (convenzione: per uso interno)."""
        print("Questo è un metodo interno...")
    
    def __metodo_privato(self):
        """Metodo privato (name mangling)."""
        print("Questo è un metodo privato molto segreto!")


# Usiamo la classe
conto = ContoBancario("Mario Rossi", 1000)

# ✅ Accesso pubblico - OK
print(f"
Titolare: {conto.titolare}")
conto.deposita(500)
conto.preleva(200)

# ✅ Getter per il saldo - OK (modo corretto)
print(f"Saldo attuale: €{conto.get_saldo():.2f}")

# ⚠️  Accesso protetto - tecnicamente possibile ma sconsigliato
print(f"
Numero conto (protetto): {conto._numero_conto}")

# ❌ Accesso privato diretto - ERRORE!
try:
    print(conto.__saldo)  # Questo darà errore!
except AttributeError as e:
    print(f"
❌ Errore: {e}")

# 🔓 Ma Python permette comunque l'accesso tramite name mangling
# (da non fare mai in produzione!)
print(f"
🔓 Saldo tramite name mangling: €{conto._ContoBancario__saldo:.2f}")
print("(ma non dovresti farlo!)")

class Persona:
    def __init__(self, nome, eta):
        self._nome = nome
        self._eta = eta  # Usiamo _ per indicare che è interno
    
    # Property per 'eta' - funziona come getter
    @property
    def eta(self):
        """Restituisce l'età della persona."""
        return self._eta
    
    # Setter per 'eta' - permette di controllare il valore
    @eta.setter
    def eta(self, valore):
        """Imposta l'età con validazione."""
        if not isinstance(valore, int):
            raise TypeError("L'età deve essere un numero intero!")
        if valore < 0 or valore > 150:
            raise ValueError("L'età deve essere tra 0 e 150!")
        self._eta = valore
    
    # Property di sola lettura (solo getter, no setter)
    @property
    def maggiorenne(self):
        """Indica se la persona è maggiorenne."""
        return self._eta >= 18


# Uso delle property - sembra accesso diretto ma passa attraverso i metodi!
p = Persona("Laura", 25)

# Leggiamo l'età (chiama il getter)
print(f"Età: {p.eta}")  # Output: Età: 25

# Modifichiamo l'età (chiama il setter con validazione)
p.eta = 30
print(f"Nuova età: {p.eta}")  # Output: Nuova età: 30

# La property maggiorenne è di sola lettura
print(f"Maggiorenne: {p.maggiorenne}")  # Output: Maggiorenne: True

# Proviamo a impostare un valore non valido
try:
    p.eta = -5  # Il setter solleverà un'eccezione
except ValueError as e:
    print(f"Errore: {e}")

import math

class Vector:
    """
    Rappresenta un vettore bidimensionale con operazioni matematiche.
    Dimostra l'uso di vari metodi speciali.
    """
    
    def __init__(self, x, y):
        """Inizializza il vettore con coordinate x e y."""
        self.x = x
        self.y = y
    
    def __str__(self):
        """Rappresentazione leggibile per l'utente."""
        return f"Vector({self.x}, {self.y})"
    
    def __repr__(self):
        """Rappresentazione tecnica per sviluppatori."""
        return f"Vector(x={self.x}, y={self.y})"
    
    def __add__(self, other):
        """Somma di due vettori: v1 + v2"""
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        """Sottrazione di due vettori: v1 - v2"""
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        """Moltiplicazione per uno scalare: v * n"""
        return Vector(self.x * scalar, self.y * scalar)
    
    def __truediv__(self, scalar):
        """Divisione per uno scalare: v / n"""
        if scalar == 0:
            raise ValueError("Divisione per zero!")
        return Vector(self.x / scalar, self.y / scalar)
    
    def __eq__(self, other):
        """Verifica uguaglianza: v1 == v2"""
        return self.x == other.x and self.y == other.y
    
    def __abs__(self):
        """Calcola il modulo del vettore: abs(v)"""
        return math.sqrt(self.x**2 + self.y**2)
    
    def __bool__(self):
        """Converte a booleano: bool(v) - False se vettore nullo"""
        return self.x != 0 or self.y != 0
    
    def __len__(self):
        """Restituisce la dimensione (sempre 2 per vettore 2D)"""
        return 2
    
    def __getitem__(self, index):
        """Accesso per indice: v[0] restituisce x, v[1] restituisce y"""
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError("Indice deve essere 0 o 1")


# ====================================
# TESTIAMO I METODI SPECIALI
# ====================================

v1 = Vector(3, 4)
v2 = Vector(1, 2)

print("=== RAPPRESENTAZIONE ===")
print(f"str(v1): {str(v1)}")       # Chiama __str__
print(f"repr(v1): {repr(v1)}")     # Chiama __repr__

print("
=== OPERAZIONI ARITMETICHE ===")
print(f"v1 + v2 = {v1 + v2}")       # Chiama __add__
print(f"v1 - v2 = {v1 - v2}")       # Chiama __sub__
print(f"v1 * 3 = {v1 * 3}")         # Chiama __mul__
print(f"v1 / 2 = {v1 / 2}")         # Chiama __truediv__

print("
=== CONFRONTI ===")
print(f"v1 == v2: {v1 == v2}")     # Chiama __eq__
print(f"v1 == Vector(3, 4): {v1 == Vector(3, 4)}")

print("
=== FUNZIONI BUILT-IN ===")
print(f"abs(v1) = {abs(v1)}")       # Chiama __abs__
print(f"len(v1) = {len(v1)}")       # Chiama __len__
print(f"bool(v1) = {bool(v1)}")     # Chiama __bool__
print(f"bool(Vector(0, 0)) = {bool(Vector(0, 0))}")

print("
=== ACCESSO PER INDICE ===")
print(f"v1[0] = {v1[0]}")           # Chiama __getitem__
print(f"v1[1] = {v1[1]}")           # Chiama __getitem__

from datetime import datetime, timedelta
from typing import List, Optional

class Libro:
    """
    Rappresenta un libro nella biblioteca.
    Dimostra: incapsulamento, property, metodi speciali.
    """
    
    # Attributo di classe (condiviso da tutte le istanze)
    _prossimo_id = 1
    
    def __init__(self, titolo: str, autore: str, isbn: str, copie: int = 1):
        self.__id = Libro._prossimo_id
        Libro._prossimo_id += 1
        
        self._titolo = titolo
        self._autore = autore
        self._isbn = isbn
        self._copie_totali = copie
        self._copie_disponibili = copie
    
    # Property con getter e setter
    @property
    def id(self):
        return self.__id
    
    @property
    def titolo(self):
        return self._titolo
    
    @property
    def autore(self):
        return self._autore
    
    @property
    def isbn(self):
        return self._isbn
    
    @property
    def disponibile(self):
        return self._copie_disponibili > 0
    
    def presta(self) -> bool:
        """Presta una copia del libro se disponibile."""
        if self._copie_disponibili > 0:
            self._copie_disponibili -= 1
            return True
        return False
    
    def restituisci(self):
        """Restituisce una copia del libro."""
        if self._copie_disponibili < self._copie_totali:
            self._copie_disponibili += 1
    
    def __str__(self):
        status = "📗 Disponibile" if self.disponibile else "📕 Non disponibile"
        return f"{status} | '{self.titolo}' di {self.autore} ({self._copie_disponibili}/{self._copie_totali} copie)"
    
    def __repr__(self):
        return f"Libro(id={self.__id}, titolo='{self.titolo}', isbn='{self.isbn}')"


class Utente:
    """
    Rappresenta un utente della biblioteca.
    Classe base che può essere estesa.
    """
    
    def __init__(self, nome: str, cognome: str, email: str):
        self._nome = nome
        self._cognome = cognome
        self._email = email
        self._libri_prestati: List[tuple] = []  # Lista di (libro, data_prestito)
        self._max_prestiti = 3
    
    @property
    def nome_completo(self):
        return f"{self._nome} {self._cognome}"
    
    @property
    def email(self):
        return self._email
    
    @property
    def num_libri_prestati(self):
        return len(self._libri_prestati)
    
    def puo_prendere_prestito(self) -> bool:
        return self.num_libri_prestati < self._max_prestiti
    
    def __str__(self):
        return f"👤 {self.nome_completo} ({self.email}) - {self.num_libri_prestati} libri in prestito"


class StudenteUniversitario(Utente):
    """
    Estende Utente per studenti universitari.
    Dimostra: ereditarietà, override, super().
    """
    
    def __init__(self, nome: str, cognome: str, email: str, matricola: str):
        super().__init__(nome, cognome, email)
        self._matricola = matricola
        self._max_prestiti = 5  # Gli studenti possono prendere più libri!
    
    @property
    def matricola(self):
        return self._matricola
    
    def __str__(self):
        # Override con estensione
        base_str = super().__str__()
        return f"🎓 {base_str} [Matricola: {self.matricola}]"


class Prestito:
    """
    Rappresenta un prestito di un libro a un utente.
    """
    
    def __init__(self, libro: Libro, utente: Utente, giorni_prestito: int = 14):
        self.libro = libro
        self.utente = utente
        self.data_prestito = datetime.now()
        self.data_scadenza = self.data_prestito + timedelta(days=giorni_prestito)
        self.data_restituzione: Optional[datetime] = None
    
    @property
    def attivo(self):
        return self.data_restituzione is None
    
    @property
    def scaduto(self):
        return self.attivo and datetime.now() > self.data_scadenza
    
    def restituisci(self):
        self.data_restituzione = datetime.now()
    
    def __str__(self):
        status = "⚠️ SCADUTO" if self.scaduto else "✅ Attivo" if self.attivo else "✓ Restituito"
        return f"{status} | {self.libro.titolo} → {self.utente.nome_completo}"


class Biblioteca:
    """
    Gestisce l'intera biblioteca.
    Dimostra: composizione, gestione di collezioni, logica di business.
    """
    
    def __init__(self, nome: str):
        self.nome = nome
        self._libri: List[Libro] = []
        self._utenti: List[Utente] = []
        self._prestiti: List[Prestito] = []
    
    def aggiungi_libro(self, libro: Libro):
        self._libri.append(libro)
        print(f"📚 Aggiunto libro: {libro.titolo}")
    
    def registra_utente(self, utente: Utente):
        self._utenti.append(utente)
        print(f"👤 Registrato utente: {utente.nome_completo}")
    
    def presta_libro(self, libro: Libro, utente: Utente) -> bool:
        """Gestisce il prestito di un libro a un utente."""
        if not utente.puo_prendere_prestito():
            print(f"❌ {utente.nome_completo} ha raggiunto il limite di prestiti!")
            return False
        
        if not libro.disponibile:
            print(f"❌ '{libro.titolo}' non è disponibile!")
            return False
        
        if libro.presta():
            prestito = Prestito(libro, utente)
            self._prestiti.append(prestito)
            utente._libri_prestati.append((libro, prestito.data_prestito))
            print(f"✅ Prestito effettuato: '{libro.titolo}' a {utente.nome_completo}")
            return True
        return False
    
    def restituisci_libro(self, libro: Libro, utente: Utente):
        """Gestisce la restituzione di un libro."""
        # Trova il prestito attivo
        for prestito in self._prestiti:
            if prestito.libro == libro and prestito.utente == utente and prestito.attivo:
                prestito.restituisci()
                libro.restituisci()
                # Rimuovi dalla lista dell'utente
                utente._libri_prestati = [(l, d) for l, d in utente._libri_prestati if l != libro]
                print(f"✅ Restituito: '{libro.titolo}' da {utente.nome_completo}")
                return
        print(f"❌ Prestito non trovato!")
    
    def cerca_libro(self, termine: str) -> List[Libro]:
        """Cerca libri per titolo o autore."""
        termine = termine.lower()
        return [l for l in self._libri 
                if termine in l.titolo.lower() or termine in l.autore.lower()]
    
    def libri_disponibili(self) -> List[Libro]:
        return [l for l in self._libri if l.disponibile]
    
    def prestiti_scaduti(self) -> List[Prestito]:
        return [p for p in self._prestiti if p.scaduto]
    
    def stampa_catalogo(self):
        print(f"
📚 === CATALOGO {self.nome.upper()} ===")
        for libro in self._libri:
            print(f"   {libro}")
    
    def stampa_utenti(self):
        print(f"
👥 === UTENTI REGISTRATI ===")
        for utente in self._utenti:
            print(f"   {utente}")
    
    def stampa_prestiti(self):
        print(f"
📋 === PRESTITI ATTIVI ===")
        prestiti_attivi = [p for p in self._prestiti if p.attivo]
        if prestiti_attivi:
            for prestito in prestiti_attivi:
                print(f"   {prestito}")
        else:
            print("   Nessun prestito attivo")


# ========================================
# DEMO DEL SISTEMA
# ========================================

if __name__ == "__main__":
    # Creiamo una biblioteca
    biblioteca = Biblioteca("Biblioteca Comunale")
    print(f"🏛️  Benvenuti alla {biblioteca.nome}!
")
    
    # Aggiungiamo alcuni libri
    libro1 = Libro("Il Nome della Rosa", "Umberto Eco", "978-0156001311", copie=2)
    libro2 = Libro("1984", "George Orwell", "978-0451524935", copie=1)
    libro3 = Libro("Il Signore degli Anelli", "J.R.R. Tolkien", "978-0544003415", copie=3)
    
    biblioteca.aggiungi_libro(libro1)
    biblioteca.aggiungi_libro(libro2)
    biblioteca.aggiungi_libro(libro3)
    
    # Registriamo alcuni utenti
    print("
")
    utente1 = Utente("Mario", "Rossi", "mario.rossi@email.com")
    studente1 = StudenteUniversitario("Laura", "Bianchi", "laura.bianchi@uni.it", "12345")
    
    biblioteca.registra_utente(utente1)
    biblioteca.registra_utente(studente1)
    
    # Mostriamo il catalogo
    biblioteca.stampa_catalogo()
    biblioteca.stampa_utenti()
    
    # Facciamo alcuni prestiti
    print("
📖 === OPERAZIONI DI PRESTITO ===")
    biblioteca.presta_libro(libro1, utente1)
    biblioteca.presta_libro(libro2, studente1)
    biblioteca.presta_libro(libro3, studente1)
    
    # Mostriamo i prestiti attivi
    biblioteca.stampa_prestiti()
    
    # Cerchiamo un libro
    print("
🔍 === RICERCA LIBRI ===")
    risultati = biblioteca.cerca_libro("Signore")
    print(f"Trovati {len(risultati)} risultati per 'Signore':")
    for libro in risultati:
        print(f"   - {libro}")
    
    # Restituiamo un libro
    print("
📥 === RESTITUZIONE ===")
    biblioteca.restituisci_libro(libro1, utente1)
    
    # Stato finale
    biblioteca.stampa_catalogo()
    biblioteca.stampa_prestiti()
    
    print("
✅ Demo completata!")